home *** CD-ROM | disk | FTP | other *** search
/ Atari Forever 4 / Atari Forever 4.zip / Atari Forever 4.iso / PD_THEMA / EDITOREN / 7UP_PD / GREPFILE.C < prev    next >
Text File  |  1998-03-14  |  12KB  |  466 lines
  1. /* Durchsucht Dateien nach Mustern */
  2. /*****************************************************************************
  3. *
  4. *                                              7UP
  5. *                                      Modul: GREPFILE.C
  6. *                                     (c) by TheoSoft '92
  7. *
  8. *****************************************************************************/
  9. #include <portab.h>
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <aes.h>
  14.  
  15. #if GEMDOS
  16. #include <tos.h>
  17. #include <ext.h>
  18. #include "fsel_inp.c"
  19. #else
  20. #include <dir.h>
  21. #endif
  22.  
  23. #include "forms.h"
  24. #include "windows.h"
  25. #include "7up.h"
  26. #include "version.h"
  27. #include "alert.h"
  28. /*
  29. #define VERSIONNAME    "7UP 2.11 © 1991,92 bei TheoSoft"
  30. */
  31. #define MAXPATHS 7
  32. #define ESC 0x01
  33. #define WM_BACKDROPPED    31        /* Message vom Eventhandler */
  34. #define FILEIOBUFF (32*1024L)
  35.  
  36. int    compile(char *);
  37. int    icompile(char *);
  38. char *grep(char *,char *,int *);
  39. char *igrep(char *,char *,int *);
  40. char *split_fname(char *filename);
  41. WINDOW *Wreadtempfile(char *filename, int mode);
  42. char *stradj(char *dest, char *src, int maxlen);
  43. long tfork(int cdecl (*func)(long), long arg);
  44. extern OBJECT *findmenu,*grepmenu;
  45. extern char alertstr[],iostring[],iostr2[],searchstring[];
  46. extern int cut;
  47. extern LINESTRUCT *begcut,*endcut;
  48.  
  49. static char pattern[FILENAME_MAX],filename[PATH_MAX];
  50. static int all,files,folders,abbruch=FALSE,Xmode=FALSE;
  51. static long found;
  52. static FILE *gp;
  53. static int msgbuf[8];
  54.  
  55. static MEVENT mevent=
  56. {
  57.     MU_TIMER|MU_KEYBD|MU_MESAG,
  58.     0,0,0,
  59.     0,0,0,0,0,
  60.     0,0,0,0,0,
  61.     msgbuf,
  62.     0L,
  63.     0,0,0,0,0,0,
  64. /* nur der Vollständigkeit halber die Variablen von XGEM */
  65.     0,0,0,0,0,
  66.     0,
  67.     0L,
  68.     0L,0L
  69. };
  70.  
  71. static char *stradj(char *dest, char *src, int maxlen)
  72. {
  73.     register int len;
  74.     if((len=strlen(src))>maxlen)
  75.     {
  76.         strncpy(dest,src,maxlen/2);
  77.         strncpy(&dest[maxlen/2],&src[len-maxlen/2],maxlen/2);
  78.         dest[maxlen/2-1]='.';
  79.         dest[maxlen/2+0]='.';
  80.         dest[maxlen/2+1]='.';
  81.         return(dest);
  82.     }
  83.     return(src);
  84. }
  85.  
  86. static int grepfile(OBJECT *tree, char *fname)
  87. {
  88.     FILE *fp=NULL;
  89.     int dummy,event,line=0,len,f=0;
  90.     char *cp, string[29];
  91.     WINDOW *wp;
  92.     extern int dial_handle;
  93.  
  94.     event=evnt_event(&mevent);
  95.     wind_update(BEG_UPDATE);
  96.     if(event & MU_MESAG)
  97.     {
  98.         if((msgbuf[0] != MN_SELECTED) && (msgbuf[0] < 50)) /* AP_TERM */
  99.         {
  100.             if(msgbuf[3]==dial_handle) /* Dialogfenster */
  101.             {
  102.                 switch(msgbuf[0])
  103.                 {
  104.                     case WM_BACKDROPPED: /* nein, niemals */
  105.                         break;
  106.                     case WM_REDRAW:
  107.                         fwind_redraw(tree,msgbuf[3],&msgbuf[4]);
  108.                         break;
  109.                     case WM_MOVED:
  110.                         fwind_move(tree,msgbuf[3],&msgbuf[4]);
  111.                         break;
  112.                     case WM_TOPPED:
  113.                         wind_set(msgbuf[3],WF_TOP,0,0,0,0);
  114.                         break;
  115.                 }
  116.             }
  117.             else /* aber kein Schließen oder Toppen */
  118.                 if(msgbuf[0]!=WM_CLOSED && msgbuf[0]!=WM_TOPPED)
  119.                     Wwindmsg(Wp(msgbuf[3]),msgbuf);
  120.         }
  121.     }
  122.     if(event&MU_KEYBD)
  123.     {
  124.         if((mevent.e_kr>>8)==ESC)                             /* ESC gedrückt? */
  125.             if(form_alert(2,Agrepfile[0])==2)
  126.                 abbruch=TRUE;
  127.     }
  128.     wind_update(END_UPDATE);
  129.  
  130.     if(!(tree[GREPGREP].ob_state&SELECTED)) /* normal suchen */
  131.     {
  132.         form_read(tree,GREPPATT,alertstr);
  133.         len=strlen(alertstr);
  134.     }
  135.  
  136.     if(!abbruch && (fp=fopen(fname,"r"))!=NULL)
  137.     {
  138. #if GEMDOS
  139.         setvbuf(fp,NULL,_IOFBF,min(filelength(fileno(fp)),FILEIOBUFF));
  140. #endif
  141. /*
  142.       form_write(tree,GREPNAME,strlen(fname)>28?&fname[strlen(fname)-28]:fname,TRUE);/* Namen einblenden */
  143. */
  144.       form_write(tree,GREPNAME,stradj(string, fname, 28),TRUE);/* Namen einblenden */
  145.       
  146.         while(fgets(iostr2,STRING_LENGTH+2,fp)!=NULL)
  147.         {
  148.             line++;
  149.             stpexpan(iostring,iostr2,((wp=Wgettop())!=NULL)?wp->tab:3,STRING_LENGTH,&dummy);
  150.  
  151.          if(tree[GREPGREP].ob_state&SELECTED)
  152.                cp=grep(iostring,iostring,&len); /* reguläre Ausdrücke */
  153.             else
  154.                cp=strstr(iostring,alertstr);         /* normal suchen */
  155. /*
  156.             cp=grep(iostring,iostring,&len);
  157. */
  158.          if(cp)
  159.             {
  160.                 if(!f)
  161.                 {
  162.                     fprintf(gp,"\nDatei %s\n",fname);
  163.                     files++;
  164.                 }
  165.                 found++;
  166.                 f++;
  167.                 fprintf(gp,"%-4d %-3d %-3d: %s",line,(int)(cp-iostring)+1,len,iostring);
  168.                 if(!all)
  169.                 {
  170.                     fclose(fp);
  171.                     return(f);
  172.                 }
  173.             }
  174.         }
  175.         if(f)
  176.             fprintf(gp,"%d Textstelle(n)\n",f);
  177.         fclose(fp);
  178.     }
  179.     return(f);
  180. }
  181.  
  182. static char lfilename[PATH_MAX];
  183.  
  184. static int walktree(OBJECT *tree,char *path)
  185. {
  186.     struct ffblk l_dta;
  187.     char l_name[100];
  188.  
  189.     sprintf(l_name,"%s%s",path,pattern);
  190.     if(!findfirst(l_name,&l_dta,0))
  191.     {
  192.         sprintf(filename,"%s%s",path,l_dta.ff_name);
  193.         /*31.12.95*/
  194.         if(strcmp(filename, lfilename))/*Zieldatei nicht nochmal bewerten!*/
  195.             grepfile(tree,filename);
  196.         
  197.         while(!findnext(&l_dta))
  198.         {
  199.             sprintf(filename,"%s%s",path,l_dta.ff_name);
  200.             /*31.12.95*/
  201.             if(strcmp(filename, lfilename))/*Zieldatei nicht nochmal bewerten!*/
  202.                 grepfile(tree,filename);
  203.         }
  204.     }
  205.     if(!(grepmenu[GREPFOLD].ob_state & SELECTED))
  206.         return;
  207.     sprintf(l_name,"%s*.*",path);
  208.     if(!findfirst(l_name,&l_dta,0x10))
  209.     {
  210.         if(l_dta.ff_attrib & 0x10)
  211.             if(strcmp(l_dta.ff_name,".") && strcmp(l_dta.ff_name,".."))
  212.             {
  213.                 folders++;
  214.                 if(Xmode)
  215.                     sprintf(l_name,"%s%s/",path,l_dta.ff_name);
  216.                 else
  217.                     sprintf(l_name,"%s%s\\",path,l_dta.ff_name);
  218.                 walktree(tree,l_name);
  219.             }
  220.             while(!findnext(&l_dta))
  221.             {
  222.                 if(l_dta.ff_attrib & 0x10)
  223.                     if(strcmp(l_dta.ff_name,".") && strcmp(l_dta.ff_name,".."))
  224.                     {
  225.                         folders++;
  226.                         if(Xmode)
  227.                             sprintf(l_name,"%s%s/",path,l_dta.ff_name);
  228.                         else
  229.                             sprintf(l_name,"%s%s\\",path,l_dta.ff_name);
  230.                         walktree(tree,l_name);
  231.                     }
  232.           }
  233.      }
  234. }
  235.  
  236. char lpath[MAXPATHS][PATH_MAX]={"","","","","","",""};
  237. char *lname[MAXPATHS]={lpath[0],lpath[1],lpath[2],lpath[3],lpath[4],lpath[5],lpath[6]};
  238.  
  239. void hndl_grepmenu(OBJECT *tree, int start)
  240. {
  241.     int a,b,c,i,exit_obj,thread=FALSE;
  242.  
  243.     char *cp,pathname[PATH_MAX],openmodus[2];
  244.  
  245.     int done=FALSE,ret,kstate;
  246.     /*static*/ char fpattern[FILENAME_MAX]="*.*";
  247.     /*static*/ char gpattern[FILENAME_MAX]="*.REG";
  248.    extern int windials;
  249.    
  250.     all=found=files=folders=0;
  251.     a=tree[GREPALL ].ob_state;
  252.     b=tree[GREPFOLD].ob_state;
  253.     c=tree[GREPMARK].ob_state;
  254.     abbruch=FALSE;
  255. /*
  256.     if(getenv("UNIXMODE")!=NULL)
  257.         Xmode=TRUE;
  258.     else
  259. */
  260.        Xmode=FALSE;
  261. /*    
  262.     local.tree=tree;
  263. */    
  264.     if(begcut && endcut && begcut==endcut && endcut->begcol<endcut->used)
  265.     {
  266.          strncpy(alertstr,&begcut->string[begcut->begcol],begcut->endcol-begcut->begcol);
  267.          alertstr[begcut->endcol-begcut->begcol]=0;
  268.          alertstr[tree[GREPPATT].ob_spec.tedinfo->te_txtlen-1]=0;
  269.          form_write(tree,GREPPATT,alertstr,FALSE);
  270.     }
  271. #if GEMDOS
  272.     if( slct_check(0x0100) && tree[GREPMARK].ob_state == DISABLED)
  273.         tree[GREPMARK].ob_state = NORMAL;
  274.     if(!slct_check(0x0100))
  275.         tree[GREPMARK].ob_state = DISABLED;
  276. #else
  277.     tree[GREPMARK].ob_state = DISABLED;
  278. #endif
  279.    form_write(tree,GREPNAME,"",FALSE);/* letzten Namen löschen */
  280.     form_exopen(tree, 0);
  281.     do
  282.     {
  283.         exit_obj=form_exdo(tree, start);
  284.         switch(exit_obj)
  285.         {
  286.             case GREPHELP:
  287.              if(tree[GREPGREP].ob_state&SELECTED) /* bei reg. Exp. */
  288.              {
  289.                    if(form_alert(2,Agrepfile[6])==2)
  290.                       if(form_alert(2,Agrepfile[7])==2)
  291.                           form_alert(1,Agrepfile[8]);
  292.                 }
  293.                 else
  294.                    form_alert(1,Agrepfile[1]);
  295.                 objc_change(tree,exit_obj,0,tree->ob_x,tree->ob_y,tree->ob_width,tree->ob_height,tree[exit_obj].ob_state&~SELECTED,TRUE);
  296.                 break;
  297.             case GREPOK:
  298.                 form_read(tree,GREPPATT,alertstr);
  299.                 if(!(*alertstr))
  300.                 {
  301.                     done=TRUE;
  302.                     break;
  303.                 }
  304.              if(tree[GREPGREP].ob_state&SELECTED) /* regulärer Ausdruck */
  305.                     if(!compile(alertstr)) /* immer kompilieren !!! */
  306.                     {
  307.                         done=TRUE;
  308.                         break;
  309.                     }
  310. #if GEMDOS
  311.                 if(tree[GREPMARK].ob_state & SELECTED)
  312.                 {
  313.                     slct_morenames(0, MAXPATHS,lname); /* we want more */
  314.                     /*local.*/pathname[0]=0;
  315.                     getfilename(/*local.*/pathname,fpattern,"@",fselmsg[17]);
  316.                     if(!/*local.*/pathname[0]) /* Kunde will nicht */
  317.                     {
  318.                         done=TRUE;
  319.                         break;
  320.                     }
  321.                 }
  322.                 else
  323. #endif
  324.                 {
  325.                     for(i=0; i<MAXPATHS; i++)
  326.                     {
  327.                         sprintf(&alertstr[100],"%d. Startverzeichnis/Suchmuster",i+1);
  328.                         *lpath[i]=0;
  329.                         if(!getfilename(lpath[i],fpattern,"@",&alertstr[100]))
  330.                             break;
  331.                     }
  332.                     if(!*lpath[0]) /* Kunde will nicht */
  333.                     {
  334.                         done=TRUE;
  335.                         break;
  336.                     }
  337.                 }
  338.                 /*local.*/lfilename[0]=0;
  339.                 if(getfilename(/*local.*/lfilename,gpattern,"7UP.REG",fselmsg[18]))
  340.                 {
  341.                     if(!windials) /* Hintergrund restaurieren */
  342.                         objc_update(tree,ROOT,MAX_DEPTH);
  343.                     if(!strstr(/*local.*/lfilename,".REG"))
  344.                     {
  345.                         form_alert(1,Agrepfile[3]);
  346.                         done=TRUE;
  347.                         break;
  348.                     }
  349.                     graf_mkstate(&ret,&ret,&ret,&kstate);
  350.                     if(kstate & (K_LSHIFT|K_RSHIFT))        /* bei gedrückter Shifttaste... */
  351.                         strcpy(/*local.*/openmodus,"a");                 /* ans Regfile anhängen,...*/
  352.                     else
  353.                         strcpy(/*local.*/openmodus,"w");                 /* ...sonst neue Datei         */
  354. /*
  355.                     thread=tree[GREPTHREAD].ob_state&SELECTED;
  356.                     if(thread)
  357.                         tfork(_searchfiles, 0L);
  358.                     else
  359.                         _searchfiles(0L);
  360. */                    
  361.                     if((gp=fopen(lfilename,openmodus))!=NULL)
  362.                     {
  363. #if GEMDOS
  364.                         setvbuf(gp,NULL,_IOFBF,FILEIOBUFF/8);
  365. #endif
  366.                         fprintf(gp,"%s\n\n",VERSIONNAME);
  367.                         fprintf(gp,"Gesucht: \"%s\"\n",alertstr);
  368. #if GEMDOS
  369.                         if(tree[GREPMARK].ob_state & SELECTED)
  370.                         {
  371.                             folders=1;
  372.                             for(i=0; i<slct->out_count; i++)
  373.                             {  /* Pfadnamen zusammenbasteln */
  374.                                 if((cp=strrchr(pathname,'\\'))!=NULL || 
  375.                                     (cp=strrchr(pathname,'/'))!=NULL)
  376.                                 {
  377.                                     cp[1]=0;
  378.                                     strcat(pathname,lpath[i]);
  379.                                     all=(tree[GREPALL].ob_state & SELECTED);
  380.                                     grepfile(tree,pathname);
  381.                                 }
  382.                             }
  383.                         }
  384.                         else
  385. #endif
  386.                         {
  387.                             for(i=0; i<MAXPATHS-2 && *lpath[i]; i++)
  388.                             {
  389.                                 if((cp=strrchr(lpath[i],'\\'))!=NULL || 
  390.                                     (cp=strrchr(lpath[i],'/'))!=NULL)
  391.                                 {
  392.                                     strcpy(pattern,cp+1L);
  393.                                     cut_path(lpath[i]);
  394. /*
  395.                                     strcut(lpath[i],'\\');
  396. */
  397.                                     all=(tree[GREPALL].ob_state & SELECTED);
  398.                                     walktree(tree,lpath[i]);
  399.                                 }
  400.                             }
  401.                         }
  402.                         fprintf(gp,"\n%ld Textstelle(n) in %d Datei(en) in %d Ordner(n).\n\n",found,files,folders+1);
  403.                         fclose(gp);
  404.                     }
  405.                     else
  406.                     {
  407.                         sprintf(alertstr,Agrepfile[5],(char *)split_fname(filename));
  408.                         form_alert(1,alertstr);
  409.                     }
  410.                 }
  411.             case GREPABBR:
  412.                 done=TRUE;
  413.                 break;
  414.         }
  415.     }
  416.     while(!done);
  417.     form_exclose(tree, exit_obj, 0);
  418.     if(exit_obj==GREPABBR)
  419.     {
  420.         tree[GREPALL ].ob_state=a;
  421.         tree[GREPFOLD].ob_state=b;
  422.         tree[GREPMARK].ob_state=c;
  423.         return;
  424.     }
  425.     if(files)
  426.     {
  427.         if(!thread)
  428.             Wreadtempfile(/*local.*/lfilename,0);
  429.     }
  430.     else
  431.     {
  432.         unlink(/*local.*/lfilename);
  433.     }
  434. }
  435.  
  436. int prepare(OBJECT *tree, OBJECT *tree2, char *str)
  437. {
  438.     form_write(tree,FINDSTR ,str,FALSE);
  439.     form_write(tree,FINDREPL,"",FALSE);
  440.  
  441.       if(tree2[GREPGREP].ob_state & SELECTED) /* regulärer Ausdruck */
  442.    {
  443.         tree[FINDNORM].ob_state=NORMAL;
  444.         tree[FINDMAT ].ob_state=NORMAL;
  445.         tree[FINDGREP].ob_state=SELECTED;
  446.     }
  447.     else
  448.     {
  449.         tree[FINDNORM].ob_state=SELECTED;
  450.         tree[FINDMAT ].ob_state=NORMAL;
  451.         tree[FINDGREP].ob_state=NORMAL;
  452.     }
  453.     tree[FINDSUCH].ob_state=SELECTED;
  454.     tree[FINDERS ].ob_state=NORMAL;
  455.  
  456.     tree[FINDBLK ].ob_state=DISABLED;
  457.     tree[FINDIGNO].ob_state=SELECTED;
  458.     tree[FINDFORW].ob_state=SELECTED;
  459.     tree[FINDASK ].ob_state=DISABLED;
  460.  
  461.     tree[FINDANF ].ob_state=NORMAL;
  462.     tree[FINDWORD].ob_state=DISABLED;
  463.     tree[FINDBACK].ob_state=DISABLED;
  464.     tree[FINDALL ].ob_state=DISABLED;
  465. }ə
  466.